home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / machine / turbo.c < prev    next >
C/C++ Source or Header  |  2000-04-23  |  6KB  |  300 lines
  1. /*************************************************************************
  2.  
  3.      Turbo - Sega - 1981
  4.  
  5.      Machine Hardware
  6.  
  7. *************************************************************************/
  8.  
  9. #include "driver.h"
  10. #include "machine/8255ppi.h"
  11.  
  12. /* globals */
  13. UINT8 turbo_opa, turbo_opb, turbo_opc;
  14. UINT8 turbo_ipa, turbo_ipb, turbo_ipc;
  15. UINT8 turbo_fbpla, turbo_fbcol;
  16. UINT8 turbo_segment_data[32];
  17. UINT8 turbo_speed;
  18.  
  19. /* local data */
  20. static UINT8 segment_address, segment_increment;
  21. static UINT8 osel, bsel, accel;
  22.  
  23. /* prototypes */
  24. extern UINT8 turbo_collision;
  25.  
  26.  
  27. /*******************************************
  28.  
  29.     Sample handling
  30.  
  31. *******************************************/
  32.  
  33. static void update_samples(void)
  34. {
  35.     /* accelerator sounds */
  36.     /* BSEL == 3 --> off */
  37.     /* BSEL == 2 --> standard */
  38.     /* BSEL == 1 --> tunnel */
  39.     /* BSEL == 0 --> ??? */
  40.     if (bsel == 3 && sample_playing(6))
  41.         sample_stop(6);
  42.     else if (bsel != 3 && !sample_playing(6))
  43.         sample_start(6, 7, 1);
  44.     if (sample_playing(6))
  45. //        sample_set_freq(6, 44100 * (accel & 0x3f) / 7 + 44100);
  46.         sample_set_freq(6, 44100 * (accel & 0x3f) / 5.25 + 44100);
  47. }
  48.  
  49.  
  50. /*******************************************
  51.  
  52.     8255 PPI handling
  53.  
  54. *******************************************/
  55. /*
  56.     chip index:
  57.     0 = IC75 - CPU Board, Sheet 6, D7
  58.     1 = IC32 - CPU Board, Sheet 6, D6
  59.     2 = IC123 - CPU Board, Sheet 6, D4
  60.     3 = IC6 - CPU Board, Sheet 5, D7
  61. */
  62.  
  63. static int portA_r(int chip)
  64. {
  65.     if (chip == 3)
  66.         return readinputport(4);     /* Wheel */
  67.     return 0;
  68. }
  69.  
  70. static int portB_r(int chip)
  71. {
  72.     if (chip == 3)
  73.         return readinputport(2);    /* DSW 2 */
  74.     return 0;
  75. }
  76.  
  77. static void portA_w(int chip, int data)
  78. {
  79.     switch (chip)
  80.     {
  81.         case 0: /* signals 0PA0 to 0PA7 */
  82.             turbo_opa = data;
  83.             break;
  84.  
  85.         case 1: /* signals 1PA0 to 1PA7 */
  86.             turbo_ipa = data;
  87.             break;
  88.  
  89.         case 2: /* signals 2PA0 to 2PA7 */
  90.             /*
  91.                 2PA0 = /CRASH
  92.                 2PA1 = /TRIG1
  93.                 2PA2 = /TRIG2
  94.                 2PA3 = /TRIG3
  95.                 2PA4 = /TRIG4
  96.                 2PA5 = OSEL0
  97.                 2PA6 = /SLIP
  98.                 2PA7 = /CRASHL
  99.             */
  100.             /* missing short crash sample, but I've never seen it triggered */
  101.             if (!(data & 0x02)) sample_start(0, 0, 0);
  102.             if (!(data & 0x04)) sample_start(0, 1, 0);
  103.             if (!(data & 0x08)) sample_start(0, 2, 0);
  104.             if (!(data & 0x10)) sample_start(0, 3, 0);
  105.             if (!(data & 0x40)) sample_start(1, 4, 0);
  106.             if (!(data & 0x80)) sample_start(2, 5, 0);
  107.             osel = (osel & 6) | ((data >> 5) & 1);
  108.             update_samples();
  109.             break;
  110.     }
  111. }
  112.  
  113. static void portB_w(int chip, int data)
  114. {
  115.     switch (chip)
  116.     {
  117.         case 0: /* signals 0PB0 to 0PB7 */
  118.             turbo_opb = data;
  119.             break;
  120.  
  121.         case 1: /* signals 1PB0 to 1PB7 */
  122.             turbo_ipb = data;
  123.             break;
  124.  
  125.         case 2: /* signals 2PB0 to 2PB7 */
  126.             /*
  127.                 2PB0 = ACC0
  128.                 2PB1 = ACC1
  129.                 2PB2 = ACC2
  130.                 2PB3 = ACC3
  131.                 2PB4 = ACC4
  132.                 2PB5 = ACC5
  133.                 2PB6 = /AMBU
  134.                 2PB7 = /SPIN
  135.             */
  136.             accel = data & 0x3f;
  137.             update_samples();
  138.             if (!(data & 0x40))
  139.             {
  140.                 if (!sample_playing(7))
  141.                     sample_start(7, 8, 0);
  142.                 else
  143.                     logerror("ambu didnt start\n");
  144.             }
  145.             else
  146.                 sample_stop(7);
  147.             if (!(data & 0x80)) sample_start(3, 6, 0);
  148.             break;
  149.     }
  150. }
  151.  
  152. static void portC_w(int chip, int data)
  153. {
  154.     switch (chip)
  155.     {
  156.         case 0: /* signals 0PC0 to 0PC7 */
  157.             turbo_opc = data;
  158.             break;
  159.  
  160.         case 1: /* signals 1PC0 to 1PC7 */
  161.             turbo_ipc = data;
  162.             break;
  163.  
  164.         case 2: /* signals 2PC0 to 2PC7 */
  165.             /*
  166.                 2PC0 = OSEL1
  167.                 2PC1 = OSEL2
  168.                 2PC2 = BSEL0
  169.                 2PC3 = BSEL1
  170.                 2PC4 = SPEED0
  171.                 2PC5 = SPEED1
  172.                 2PC6 = SPEED2
  173.                 2PC7 = SPEED3
  174.             */
  175.             turbo_speed = (data >> 4) & 0x0f;
  176.             bsel = (data >> 2) & 3;
  177.             osel = (osel & 1) | ((data & 3) << 1);
  178.             update_samples();
  179.             break;
  180.  
  181.         case 3:
  182.             /* bit 0-3 = signals PLA0 to PLA3 */
  183.             /* bit 4-6 = signals COL0 to COL2 */
  184.             /* bit 7 = unused */
  185.             turbo_fbpla = data & 0x0f;
  186.             turbo_fbcol = (data & 0x70) >> 4;
  187.             break;
  188.     }
  189. }
  190.  
  191. static ppi8255_interface intf =
  192. {
  193.     4, /* 4 chips */
  194.     portA_r, /* Port A read */
  195.     portB_r, /* Port B read */
  196.           0, /* Port C read */
  197.     portA_w, /* Port A write */
  198.     portB_w, /* Port B write */
  199.     portC_w, /* Port C write */
  200. };
  201.  
  202.  
  203.  
  204. /*******************************************
  205.  
  206.     Machine Init
  207.  
  208. *******************************************/
  209.  
  210. void turbo_init_machine(void)
  211. {
  212.     ppi8255_init(&intf);
  213.     segment_address = segment_increment = 0;
  214. }
  215.  
  216.  
  217. /*******************************************
  218.  
  219.     8279 handling
  220.     IC84 - CPU Board, Sheet 5, C7
  221.  
  222. *******************************************/
  223.  
  224. READ_HANDLER( turbo_8279_r )
  225. {
  226.     if ((offset & 1) == 0)
  227.         return readinputport(1);  /* DSW 1 */
  228.     else
  229.     {
  230.         logerror("read 0xfc%02x\n", offset);
  231.         return 0x10;
  232.     }
  233. }
  234.  
  235. WRITE_HANDLER( turbo_8279_w )
  236. {
  237.     switch (offset & 1)
  238.     {
  239.         case 0x00:
  240.             turbo_segment_data[segment_address * 2] = data & 15;
  241.             turbo_segment_data[segment_address * 2 + 1] = (data >> 4) & 15;
  242.             segment_address = (segment_address + segment_increment) & 15;
  243.             break;
  244.  
  245.         case 0x01:
  246.             switch (data & 0xe0)
  247.             {
  248.                 case 0x80:
  249.                     segment_address = data & 15;
  250.                     segment_increment = 0;
  251.                     break;
  252.                 case 0x90:
  253.                     segment_address = data & 15;
  254.                     segment_increment = 1;
  255.                     break;
  256.                 case 0xc0:
  257.                     memset(turbo_segment_data, 0, 32);
  258.                     break;
  259.             }
  260.             break;
  261.     }
  262. }
  263.  
  264.  
  265. /*******************************************
  266.  
  267.     Misc handling
  268.  
  269. *******************************************/
  270.  
  271. READ_HANDLER( turbo_collision_r )
  272. {
  273.     return readinputport(3) | (turbo_collision & 15);
  274. }
  275.  
  276. WRITE_HANDLER( turbo_collision_clear_w )
  277. {
  278.     turbo_collision = 0;
  279. }
  280.  
  281. WRITE_HANDLER( turbo_coin_and_lamp_w )
  282. {
  283.     data &= 1;
  284.     switch (offset & 7)
  285.     {
  286.         case 0:        /* Coin Meter 1 */
  287.         case 1:        /* Coin Meter 2 */
  288.         case 2:        /* n/c */
  289.             break;
  290.  
  291.         case 3:        /* Start Lamp */
  292.             osd_led_w(0, data);
  293.             break;
  294.  
  295.         case 4:        /* n/c */
  296.         default:
  297.             break;
  298.     }
  299. }
  300.